import nodeSchedule from "node-schedule"
import pLimit from "p-limit"
import { td_posting, td_posting_comment } from "../tasks/threads/index.js"
import { fb_join_group, fb_posting_to_group } from "../tasks/faceBook/index.js"
import { tk_live_home_follow } from "../tasks/tiktok/index.js"
import { params } from "../config/index.js"
import { stopTask } from "./index.js"
import { configMap } from "../config/index.js"
// 任务重试间隔时间（秒）
const TASK_RETRY_DELAY_SECONDS = 10

/**
 * 任务调度器类 - 负责根据时间和策略调度自动化任务
 */
class TaskScheduler {
  constructor(config = { maxConcurrentTasks: 5 }) {
    this.activeJobs = new Map() // 存储活动的调度作业 map<uniqueTaskKey, job>
    this.activeTasks = new Map() // 存储活动的任务 map<uniqueTaskKey, task>
    this.activeTasksRunning = new Map() // 存储正在运行的任务 map<uniqueTaskKey, boolean>
    this.config = config
    this.mode = params.mode || "production"
    this.concurrencyLimit = pLimit(config.maxConcurrentTasks) // 并发限制
    this.taskRetryDelayMs = TASK_RETRY_DELAY_SECONDS * 1000 // 任务重试延迟(毫秒)
  }

  /**
   * 生成任务的唯一键
   * @param {object} task - 任务对象
   * @returns {string} - 唯一任务键
   */
  generateUniqueTaskKey(task) {
    // 使用taskId和platformId组合作为唯一键
    const platformId = task.platformAccounts && task.platformAccounts.length > 0 ? task.platformAccounts[0].platformId : task.platformId

    return `${task.taskId}_${platformId}`
  }

  /**
   * 获取任务的运行时间范围
   * @param {object} task - 任务对象
   * @returns {object|null} - 返回操作时间范围对象或null
   */
  getTaskOperatingTimeRanges(task) {
    // 如果任务直接有operatingTimeRanges属性(旧格式)
    if (task.operatingTimeRanges) {
      return task.operatingTimeRanges
    }

    // 如果是新的数据格式，从platformAccounts中获取
    if (task.platformAccounts && task.platformAccounts.length > 0) {
      // 使用第一个平台账号的operatingTimeRanges
      return task.platformAccounts[0].operatingTimeRanges || null
    }

    return null
  }

  /**
   * 检查时间是否在指定的运行时间范围内
   * @param {object} timeRanges - 运行时间范围配置
   * @returns {boolean} - 是否在运行时间范围内
   */
  isWithinOperatingTimeRanges(timeRanges) {
    if (!timeRanges || !timeRanges.ranges || timeRanges.ranges.length === 0) {
      return false
    }

    const now = new Date()
    const currentHour = now.getHours()
    const currentMinute = now.getMinutes()
    const currentTimeInMinutes = currentHour * 60 + currentMinute

    try {
      console.log(`当前时间: ${currentHour}:${currentMinute} (${currentTimeInMinutes}分钟)`)
    } catch (error) {
      // 忽略日志错误，保持程序运行
    }

    // 应用随机偏移量
    const offsetMin = timeRanges.offsetMinutesMin || 0
    const offsetMax = timeRanges.offsetMinutesMax || 0
    const randomOffset = offsetMin === offsetMax ? offsetMin : Math.floor(Math.random() * (offsetMax - offsetMin + 1)) + offsetMin

    // 检查是否在任意时间范围内
    return timeRanges.ranges.some((range) => {
      // 解析开始和结束时间
      const [startHour, startMinute] = range.startTime.split(":").map(Number)
      const [endHour, endMinute] = range.endTime.split(":").map(Number)

      // 转换为分钟计数
      let startTimeInMinutes = startHour * 60 + startMinute + randomOffset
      let endTimeInMinutes = endHour * 60 + endMinute + randomOffset

      try {
        console.log(`检查时间范围: ${startHour}:${startMinute}(${startTimeInMinutes}分钟) - ${endHour}:${endMinute}(${endTimeInMinutes}分钟), 偏移量: ${randomOffset}分钟`)
      } catch (error) {
        // 忽略日志错误，保持程序运行
      }

      // 处理跨天情况
      if (endTimeInMinutes < startTimeInMinutes) {
        // 如果结束时间小于开始时间，说明跨天
        const isWithinRange = currentTimeInMinutes >= startTimeInMinutes || currentTimeInMinutes <= endTimeInMinutes
        try {
          console.log(`跨天时间范围判断结果: ${isWithinRange}`)
        } catch (error) {
          // 忽略日志错误，保持程序运行
        }
        return isWithinRange
      } else {
        // 正常情况，在同一天内
        const isWithinRange = currentTimeInMinutes >= startTimeInMinutes && currentTimeInMinutes <= endTimeInMinutes
        try {
          console.log(`同天时间范围判断结果: ${isWithinRange}`)
        } catch (error) {
          // 忽略日志错误，保持程序运行
        }
        return isWithinRange
      }
    })
  }

  /**
   * 计算下一次任务应该在什么时间执行
   * @param {object} task - 任务配置
   * @returns {Date|null} - 下一次执行时间，如果无法获取则返回null
   */
  calculateNextRunTime(task) {
    if (!task.composeData || task.composeData.length === 0) {
      return null
    }

    const tdPostingTask = task.composeData.find((item) => item.name === "td_posting")

    if (!tdPostingTask) {
      return null
    }

    // 获取间隔小时数
    const intervalConfig = tdPostingTask.config.find((item) => item.name === "interval_posting")
    if (!intervalConfig) {
      return null
    }

    const baseInterval = intervalConfig.value || 24 // 默认24小时

    // 获取随机倍数
    const maxCountConfig = tdPostingTask.config.find((item) => item.name === "max_count")
    const minCountConfig = tdPostingTask.config.find((item) => item.name === "min_count")

    const maxMultiplier = maxCountConfig?.value || 1.2
    const minMultiplier = minCountConfig?.value || 0.8

    // 计算随机间隔时间（小时）
    const randomMultiplier = Math.random() * (maxMultiplier - minMultiplier) + minMultiplier
    const intervalHours = baseInterval * randomMultiplier

    // 获取任务的运行时间范围
    const operatingTimeRanges = this.getTaskOperatingTimeRanges(task)

    // 如果没有设置有效时间范围，则使用原来的计算方式
    if (!operatingTimeRanges || !operatingTimeRanges.ranges || operatingTimeRanges.ranges.length === 0) {
      // 原来的计算方式：当前时间加上间隔
      const nextRunTime = new Date()
      nextRunTime.setHours(nextRunTime.getHours() + intervalHours)
      return nextRunTime
    }

    // 按照最小间隔时间计算下次运行的最早时间点
    const minIntervalTime = new Date()
    minIntervalTime.setHours(minIntervalTime.getHours() + baseInterval * minMultiplier)

    // 寻找下次有效的时间段
    const sortedRanges = [...operatingTimeRanges.ranges].sort((a, b) => {
      const [aStartHour, aStartMin] = a.startTime.split(":").map(Number)
      const [bStartHour, bStartMin] = b.startTime.split(":").map(Number)
      return aStartHour * 60 + aStartMin - (bStartHour * 60 + bStartMin)
    })

    const now = new Date()
    const tomorrow = new Date(now)
    tomorrow.setDate(tomorrow.getDate() + 1)
    tomorrow.setHours(0, 0, 0, 0)

    // 检查今天剩余的时间段
    for (const range of sortedRanges) {
      const [startHour, startMin] = range.startTime.split(":").map(Number)

      const rangeStartTime = new Date(now)
      rangeStartTime.setHours(startHour, startMin, 0, 0)

      // 如果时间段开始时间晚于当前时间，并且满足最小间隔要求
      if (rangeStartTime > now && rangeStartTime > minIntervalTime) {
        return rangeStartTime
      }
    }

    // 如果今天没有合适的时间段，则查找明天的第一个时间段
    if (sortedRanges.length > 0) {
      const [startHour, startMin] = sortedRanges[0].startTime.split(":").map(Number)
      const nextDayStart = new Date(tomorrow)
      nextDayStart.setHours(startHour, startMin, 0, 0)

      return nextDayStart
    }

    // 如果没有找到合适的时间段，则使用原来的计算方式
    const defaultNextRunTime = new Date()
    defaultNextRunTime.setHours(defaultNextRunTime.getHours() + intervalHours)
    return defaultNextRunTime
  }

  /**
   * 执行特定任务
   * @param {object} task - 任务配置
   * @returns {Promise<void>}
   */
  async executeTask(task) {
    const taskId = task.taskId
    const uniqueTaskKey = this.generateUniqueTaskKey(task)

    try {
      console.log(
        `开始执行任务: ${task.name || task.platformName}, ID: ${taskId}, 平台ID: ${
          task.platformId || (task.platformAccounts && task.platformAccounts.length > 0 ? task.platformAccounts[0].platformId : "未知")
        }`
      )
    } catch (error) {
      // 忽略日志错误，保持程序运行
    }

    try {
      // 获取任务的运行时间范围
      const operatingTimeRanges = this.getTaskOperatingTimeRanges(task)

      // 检查任务是否在运行时间段内
      if (!this.isWithinOperatingTimeRanges(operatingTimeRanges)) {
        try {
          console.log(`任务 ${uniqueTaskKey} 不在运行时间段内，跳过执行`)
        } catch (error) {
          // 忽略日志错误，保持程序运行
        }

        // 如果不在运行时间段内，计算下次执行时间
        const nextRunTime = this.calculateNextRunTime(task)
        if (nextRunTime) {
          try {
            console.log(`任务 ${uniqueTaskKey} 下次执行时间: ${nextRunTime}`)
          } catch (error) {
            // 忽略日志错误，保持程序运行
          }
          // 重新调度任务
          this.scheduleTask(task, nextRunTime)
        }
        return
      }

      // 如果任务已经在运行，跳过
      if (this.activeTasksRunning.get(uniqueTaskKey)) {
        try {
          console.log(`任务 ${uniqueTaskKey} 已经在运行中，跳过重复执行`)
        } catch (error) {
          // 忽略日志错误，保持程序运行
        }
        return
      }

      // 标记任务为运行中
      this.activeTasksRunning.set(uniqueTaskKey, true)

      // 为每个composeData构造任务对象并执行
      for (const composedTask of task.composeData) {
        await this.executeComposedTask(task, composedTask)
      }

      // 任务执行完成，标记为未运行
      this.activeTasksRunning.set(uniqueTaskKey, false)

      // 检查是否有待更新的策略
      const pendingUpdateKey = `${uniqueTaskKey}_pending_update`
      if (this.activeTasks.has(pendingUpdateKey)) {
        try {
          console.log(`任务 ${uniqueTaskKey} 执行完成，应用待更新的策略`)
        } catch (error) {
          // 忽略日志错误，保持程序运行
        }

        // 获取待更新的策略
        const updatedTask = this.activeTasks.get(pendingUpdateKey)

        // 移除待更新标记
        this.activeTasks.delete(pendingUpdateKey)

        // 取消现有任务
        await this.cancelTask(updatedTask)

        // 使用新策略重新调度
        this.scheduleTask(updatedTask)

        // 跳过后续的常规重新调度
        return
      }

      // 获取最新的运行时间范围
      const updatedTimeRanges = this.getTaskOperatingTimeRanges(task)

      // 如果仍然在运行时间段内，延迟后再次执行任务
      if (this.isWithinOperatingTimeRanges(updatedTimeRanges)) {
        console.log(`任务 ${uniqueTaskKey} 仍在运行时间段内，将在 ${TASK_RETRY_DELAY_SECONDS} 秒后继续执行`)
        setTimeout(() => {
          // 再次检查是否仍在时间段内
          const latestTimeRanges = this.getTaskOperatingTimeRanges(task)
          if (this.isWithinOperatingTimeRanges(latestTimeRanges) && !this.activeTasksRunning.get(uniqueTaskKey)) {
            this.concurrencyLimit(() => this.executeTask(task))
          }
        }, this.taskRetryDelayMs)
      } else {
        // 不在运行时间段内，计算下次执行时间
        const nextRunTime = this.calculateNextRunTime(task)
        if (nextRunTime) {
          console.log(`任务 ${uniqueTaskKey} 下次执行时间: ${nextRunTime}`)
          // 重新调度任务
          this.scheduleTask(task, nextRunTime)
        }
      }
    } catch (error) {
      // 捕获执行过程中的任何错误
      try {
        console.error(`执行任务 ${uniqueTaskKey} 时发生错误:`, error)
      } catch (logError) {
        // 忽略日志错误，保持程序运行
      }

      // 标记任务为未运行，确保不会阻塞后续任务
      this.activeTasksRunning.set(uniqueTaskKey, false)

      // 错误后延迟重试
      console.log(`任务 ${uniqueTaskKey} 执行出错，将在 ${TASK_RETRY_DELAY_SECONDS} 秒后重试`)
      setTimeout(() => {
        const retryTimeRanges = this.getTaskOperatingTimeRanges(task)
        if (this.isWithinOperatingTimeRanges(retryTimeRanges) && !this.activeTasksRunning.get(uniqueTaskKey)) {
          this.concurrencyLimit(() => this.executeTask(task))
        }
      }, this.taskRetryDelayMs)
    }
  }

  /**
   * 执行组合任务
   * @param {object} task - 主任务
   * @param {object} composedTask - 组合子任务
   * @returns {Promise<void>}
   */
  async executeComposedTask(task, composedTask) {
    try {
      // 处理新的数据格式
      const platformAccount = task.platformAccounts && task.platformAccounts.length > 0 ? task.platformAccounts[0].platformAccount : task.platformAccount

      const platformAccountNickName = task.platformAccounts && task.platformAccounts.length > 0 ? task.platformAccounts[0].nickName : task.platformAccountNickName

      const platformId = task.platformAccounts && task.platformAccounts.length > 0 ? task.platformAccounts[0].platformId : task.platformId

      // 构造任务参数
      const taskParam = {
        platformAccount: platformAccount,
        platformAccountNickName: platformAccountNickName,
        platformId: platformId,
        deviceId: `${task.deviceId}`,
        account: platformAccount,
        taskId: task.taskId,
        host: task.host,
        composedTask: composedTask,
        tenantId: task.tenantId,
        platformName: task.platformName,
        operatingTimeRanges: task.operatingTimeRanges,
      }

      // 根据不同任务类型执行不同操作
      // 这里调用的函数已经包含了浏览器的打开和关闭逻辑
      switch (composedTask.name) {
        case "td_posting":
          await td_posting([taskParam], platformAccount, 1)
          break
        case "td_posting_comment":
          await td_posting_comment([taskParam], platformAccount, 1)
          break
        case "fb_join_group":
          await fb_join_group([taskParam], platformAccount, 1)
          break
        case "fb_posting_to_group":
          await fb_posting_to_group([taskParam], platformAccount, 1)
          break
        case "tk_live_home_follow":
          await tk_live_home_follow([taskParam], platformAccount, 0)
          break
        default:
          console.warn(`未知任务类型: ${composedTask.name}`)
      }

      // 使用错误处理包装任何涉及console.log的逻辑
      try {
        console.log(`正在执行组合任务: ${composedTask.name}`)
      } catch (error) {
        // 忽略日志错误，保持程序运行
      }
    } catch (error) {
      // 捕获执行组合任务中的任何错误
      try {
        console.error(`执行组合任务 ${composedTask.name} 时发生错误:`, error)
      } catch (logError) {
        // 忽略日志错误，保持程序运行
      }
    }
  }

  /**
   * 停止指定任务的所有窗口
   * @param {string|number} taskId - 任务ID
   * @returns {Promise<void>}
   */
  async stopTaskWindows(taskId) {
    console.log(`停止任务 ${taskId} 的窗口`)

    // 使用现有的stopTask函数关闭窗口
    await stopTask(taskId, null, () => {
      console.log(`任务 ${taskId} 的所有窗口已关闭`)
    })
  }

  /**
   * 调度任务执行
   * @param {object} task - 任务配置
   * @param {Date} [specificTime] - 特定执行时间，如果不提供则立即执行
   */
  scheduleTask(task, specificTime) {
    const taskId = task.taskId
    const uniqueTaskKey = this.generateUniqueTaskKey(task)
    const platformName = task.platformName || "未知平台"

    // 如果任务已经在调度中，先取消之前的调度
    if (this.activeJobs.has(uniqueTaskKey)) {
      this.cancelTask(task)
    }

    // 记录任务
    this.activeTasks.set(uniqueTaskKey, task)
    this.activeTasksRunning.set(uniqueTaskKey, false)

    let job
    if (specificTime) {
      // 在特定时间执行
      job = nodeSchedule.scheduleJob(specificTime, () => {
        this.concurrencyLimit(() => this.executeTask(task))
      })
      console.log(`已调度任务 ${uniqueTaskKey} (${platformName}) 在 ${specificTime} 执行`)
    } else {
      // 获取任务的运行时间范围
      const operatingTimeRanges = this.getTaskOperatingTimeRanges(task)

      // 检查是否在运行时间范围内，如果在范围内，立即执行
      const isInTimeRange = this.isWithinOperatingTimeRanges(operatingTimeRanges)
      if (isInTimeRange) {
        console.log(`任务 ${uniqueTaskKey} (${platformName}) 当前在运行时间范围内，立即执行`)
        this.concurrencyLimit(() => this.executeTask(task))
      } else {
        console.log(`任务 ${uniqueTaskKey} (${platformName}) 当前不在运行时间范围内，将按计划执行`)
      }

      // 创建一个每分钟检查一次的定时任务来监控运行时间范围
      job = nodeSchedule.scheduleJob("*/1 * * * *", () => {
        // 获取最新的运行时间范围
        const latestTimeRanges = this.getTaskOperatingTimeRanges(task)

        // 只有当任务不在运行中且在运行时间范围内时，才启动任务
        const shouldRun = this.isWithinOperatingTimeRanges(latestTimeRanges) && !this.activeTasksRunning.get(uniqueTaskKey)
        if (shouldRun) {
          console.log(`定时检查: 任务 ${uniqueTaskKey} (${platformName}) 符合执行条件，启动执行`)
          this.concurrencyLimit(() => this.executeTask(task))
        }
      })
      console.log(`已设置任务 ${uniqueTaskKey} (${platformName}) 的定时监控`)
    }

    // 记录作业
    this.activeJobs.set(uniqueTaskKey, job)
  }

  /**
   * 取消指定任务
   * @param {string|number|object} taskIdOrTask - 任务ID或任务对象
   */
  async cancelTask(taskIdOrTask) {
    let uniqueTaskKey

    // 判断传入的是任务ID还是任务对象
    if (typeof taskIdOrTask === "object") {
      uniqueTaskKey = this.generateUniqueTaskKey(taskIdOrTask)
    } else {
      // 如果只传入了taskId，则尝试查找所有包含该taskId的任务
      const taskKeys = [...this.activeJobs.keys()].filter((key) => key.startsWith(`${taskIdOrTask}_`))

      if (taskKeys.length === 0) {
        // 如果找不到任务，尝试使用原始taskId
        uniqueTaskKey = taskIdOrTask
      } else {
        // 如果找到多个任务，则取消所有任务
        for (const key of taskKeys) {
          await this._cancelTaskByKey(key)
        }
        return
      }
    }

    await this._cancelTaskByKey(uniqueTaskKey)
  }

  /**
   * 通过唯一键取消任务（内部方法）
   * @param {string} uniqueTaskKey - 任务唯一键
   */
  async _cancelTaskByKey(uniqueTaskKey) {
    if (!this.activeJobs.has(uniqueTaskKey)) {
      return
    }

    console.log(`取消任务: ${uniqueTaskKey}`)

    // 取消调度
    const job = this.activeJobs.get(uniqueTaskKey)
    if (job) {
      job.cancel()
    }

    // 移除记录
    this.activeJobs.delete(uniqueTaskKey)
    this.activeTasks.delete(uniqueTaskKey)

    // 如果任务正在运行，停止相关窗口
    if (this.activeTasksRunning.get(uniqueTaskKey)) {
      const task = this.activeTasks.get(uniqueTaskKey)
      const taskId = task ? task.taskId : uniqueTaskKey.split("_")[0]
      await this.stopTaskWindows(taskId)
      this.activeTasksRunning.delete(uniqueTaskKey)
    }
  }

  /**
   * 启动调度器，处理一组任务
   * @param {Array} tasks - 任务数组
   */
  startScheduler(tasks) {
    if (!Array.isArray(tasks) || tasks.length === 0) {
      console.warn("[TaskScheduler] 没有任务需要调度")
      return
    }

    console.log(`开始调度 ${tasks.length} 个任务`)
    // 为每个任务创建调度
    tasks.forEach((task) => {
      // 获取hostInfo拿到他所有的key
      const configObjectKeys = Object.keys(task?.host || {})
      console.log("主线程>>>>>>", "configObjectKeys", configObjectKeys)
      // 遍历所有的key配置占位符
      for (let index = 0; index < configObjectKeys.length; index++) {
        const configObjectKey = configObjectKeys[index]
        if (task?.host[configObjectKey] && typeof task?.host[configObjectKey] === "string") {
          if (!configMap.get(`{${task?.host?.name}__${configObjectKey}}`)) {
            console.log("configMap=====item", `{${task?.host?.name}__${configObjectKey}}`, task?.host[configObjectKey])
            configMap.set(`{${task?.host?.name}__${configObjectKey}}`, task?.host[configObjectKey])
          }
        }
      }
      // 先创建map
      // 遍历 extendProperties 并批量设置 configMap
      task?.host?.extendProperties.forEach(({ label, value }) => {
        if (value) {
          if (!configMap.get(`{${task?.host?.name}__${label}}`)) {
            console.log("configMap=====item", `{${task?.host?.name}__${label}}`, value)
            configMap.set(`{${task?.host?.name}__${label}}`, value)
          }
        }
      })
      this.scheduleTask(task)
    })
  }

  /**
   * 停止所有任务
   */
  async stopAllTasks() {
    console.log(`停止所有任务`)

    // 获取所有任务ID
    const taskIds = [...this.activeJobs.keys()]

    // 逐个取消任务
    for (const taskId of taskIds) {
      await this.cancelTask(taskId)
    }
  }

  /**
   * 更新任务策略
   * @param {object} updatedTask - 更新后的任务配置
   * @returns {Promise<void>}
   */
  async updateTaskPolicy(updatedTask) {
    if (!updatedTask || !updatedTask.taskId) {
      console.warn(`更新任务策略失败：无效的任务配置`)
      return
    }

    const taskId = updatedTask.taskId
    const uniqueTaskKey = this.generateUniqueTaskKey(updatedTask)
    console.log(`收到任务策略更新通知, ID: ${taskId}, 唯一键: ${uniqueTaskKey}, 平台: ${updatedTask.platformName || "未知平台"}`)

    // 检查任务是否已存在
    const taskExists = this.activeTasks.has(uniqueTaskKey)

    // 情况1: 已有策略，需要更新
    if (taskExists) {
      console.log(`任务 ${uniqueTaskKey} 已存在，准备更新策略`)

      // 检查任务是否正在运行
      const isRunning = this.activeTasksRunning.get(uniqueTaskKey)

      if (isRunning) {
        console.log(`任务 ${uniqueTaskKey} 正在运行中，等待执行完成后更新策略`)

        // 设置标记，表示任务需要在完成后更新策略
        this.activeTasks.set(`${uniqueTaskKey}_pending_update`, updatedTask)

        // 继续保持现有调度任务，等待执行完成
      } else {
        // 任务不在运行中，可以立即取消并重新调度
        console.log(`任务 ${uniqueTaskKey} 未在运行，立即更新策略`)

        // 取消现有任务
        await this.cancelTask(updatedTask)

        // 获取任务的运行时间范围
        const operatingTimeRanges = this.getTaskOperatingTimeRanges(updatedTask)

        // 检查是否在运行时间范围内
        const isWithinTimeRange = this.isWithinOperatingTimeRanges(operatingTimeRanges)

        if (isWithinTimeRange) {
          console.log(`任务 ${uniqueTaskKey} 当前在运行时间范围内，立即执行`)
          // 立即调度任务
          this.scheduleTask(updatedTask)
        } else {
          // 计算下次执行时间
          const nextRunTime = this.calculateNextRunTime(updatedTask)

          if (nextRunTime) {
            console.log(`任务 ${uniqueTaskKey} 当前不在运行时间范围内，下次执行时间: ${nextRunTime}`)
            // 使用新策略重新调度，并传入计算好的执行时间
            this.scheduleTask(updatedTask, nextRunTime)
          } else {
            // 如果无法计算下次执行时间，则直接调度
            this.scheduleTask(updatedTask)
          }
        }
      }
    }
    // 情况2: 新增策略
    else {
      console.log(`任务 ${uniqueTaskKey} 不存在，创建新任务策略`)

      // 获取任务的运行时间范围
      const operatingTimeRanges = this.getTaskOperatingTimeRanges(updatedTask)

      // 检查是否在运行时间范围内
      const isWithinTimeRange = this.isWithinOperatingTimeRanges(operatingTimeRanges)

      if (isWithinTimeRange) {
        console.log(`新任务 ${uniqueTaskKey} 当前在运行时间范围内，立即执行`)
        // 立即调度任务
        this.scheduleTask(updatedTask)
      } else {
        // 计算下次执行时间
        const nextRunTime = this.calculateNextRunTime(updatedTask)

        if (nextRunTime) {
          console.log(`新任务 ${uniqueTaskKey} 当前不在运行时间范围内，首次执行时间: ${nextRunTime}`)
          // 使用计算好的执行时间调度新任务
          this.scheduleTask(updatedTask, nextRunTime)
        } else {
          // 如果无法计算下次执行时间，则直接调度
          this.scheduleTask(updatedTask)
        }
      }
    }

    return {
      success: true,
      taskId: taskId,
      message: `任务策略更新${taskExists ? "成功" : "并创建新任务"}`,
    }
  }
}

// 创建一个默认的任务调度器实例
const taskScheduler = new TaskScheduler()

export { TaskScheduler, taskScheduler }

// 导出用于更新任务策略的便捷方法
export const updateTaskPolicy = async (updatedTask) => {
  return await taskScheduler.updateTaskPolicy(updatedTask)
}

